home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / qca.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-02-25  |  10.0 KB  |  467 lines
  1. /*
  2.  * qca.h - Qt Cryptographic Architecture
  3.  * Copyright (C) 2003  Justin Karneges
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2.1 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  */
  20.  
  21. #ifndef QCA_H
  22. #define QCA_H
  23.  
  24. #include<qstring.h>
  25. #include<qcstring.h>
  26. #include<qdatetime.h>
  27. #include<qmap.h>
  28. #include<qptrlist.h>
  29. #include<qobject.h>
  30.  
  31. #ifdef Q_OS_WIN32
  32. #  ifndef QCA_STATIC
  33. #    ifdef QCA_MAKEDLL
  34. #      define QCA_EXPORT __declspec(dllexport)
  35. #    else
  36. #      define QCA_EXPORT __declspec(dllimport)
  37. #    endif
  38. #  endif
  39. #endif
  40. #ifndef QCA_EXPORT
  41. #define QCA_EXPORT
  42. #endif
  43.  
  44. #ifdef Q_OS_WIN32
  45. #  ifdef QCA_PLUGIN_DLL
  46. #    define QCA_PLUGIN_EXPORT extern "C" __declspec(dllexport)
  47. #  else
  48. #    define QCA_PLUGIN_EXPORT extern "C" __declspec(dllimport)
  49. #  endif
  50. #endif
  51. #ifndef QCA_PLUGIN_EXPORT
  52. #define QCA_PLUGIN_EXPORT extern "C"
  53. #endif
  54.  
  55. class QHostAddress;
  56. class QStringList;
  57.  
  58. class QCAProvider;
  59. class QCA_HashContext;
  60. class QCA_CipherContext;
  61. class QCA_CertContext;
  62.  
  63. namespace QCA
  64. {
  65.     enum {
  66.         CAP_SHA1      = 0x0001,
  67.         CAP_SHA256    = 0x0002,
  68.         CAP_MD5       = 0x0004,
  69.         CAP_BlowFish  = 0x0008,
  70.         CAP_TripleDES = 0x0010,
  71.         CAP_AES128    = 0x0020,
  72.         CAP_AES256    = 0x0040,
  73.         CAP_RSA       = 0x0080,
  74.         CAP_X509      = 0x0100,
  75.         CAP_TLS       = 0x0200,
  76.         CAP_SASL      = 0x0400
  77.     };
  78.  
  79.     enum {
  80.         CBC = 0x0001,
  81.         CFB = 0x0002
  82.     };
  83.  
  84.     enum {
  85.         Encrypt = 0x0001,
  86.         Decrypt = 0x0002
  87.     };
  88.  
  89.     QCA_EXPORT void init();
  90.     QCA_EXPORT bool isSupported(int capabilities);
  91.     QCA_EXPORT void insertProvider(QCAProvider *);
  92.     QCA_EXPORT void unloadAllPlugins();
  93.  
  94.     QCA_EXPORT QString arrayToHex(const QByteArray &);
  95.     QCA_EXPORT QByteArray hexToArray(const QString &);
  96.  
  97.     class QCA_EXPORT Hash
  98.     {
  99.     public:
  100.         Hash(const Hash &);
  101.         Hash & operator=(const Hash &);
  102.         ~Hash();
  103.  
  104.         void clear();
  105.         void update(const QByteArray &a);
  106.         QByteArray final();
  107.  
  108.     protected:
  109.         Hash(QCA_HashContext *);
  110.  
  111.     private:
  112.         class Private;
  113.         Private *d;
  114.     };
  115.  
  116.     template <class T>
  117.     class QCA_EXPORT HashStatic
  118.     {
  119.     public:
  120.         HashStatic<T>() {}
  121.  
  122.         static QByteArray hash(const QByteArray &a)
  123.         {
  124.             T obj;
  125.             obj.update(a);
  126.             return obj.final();
  127.         }
  128.  
  129.         static QByteArray hash(const QCString &cs)
  130.         {
  131.             QByteArray a(cs.length());
  132.             memcpy(a.data(), cs.data(), a.size());
  133.             return hash(a);
  134.         }
  135.  
  136.         static QString hashToString(const QByteArray &a)
  137.         {
  138.             return arrayToHex(hash(a));
  139.         }
  140.  
  141.         static QString hashToString(const QCString &cs)
  142.         {
  143.             return arrayToHex(hash(cs));
  144.         }
  145.     };
  146.  
  147.     class QCA_EXPORT Cipher
  148.     {
  149.     public:
  150.         Cipher(const Cipher &);
  151.         Cipher & operator=(const Cipher &);
  152.         ~Cipher();
  153.  
  154.         QByteArray dyn_generateKey(int size=-1) const;
  155.         QByteArray dyn_generateIV() const;
  156.         void reset(int dir, int mode, const QByteArray &key, const QByteArray &iv, bool pad=true);
  157.         bool update(const QByteArray &a);
  158.         QByteArray final(bool *ok=0);
  159.  
  160.     protected:
  161.         Cipher(QCA_CipherContext *, int dir, int mode, const QByteArray &key, const QByteArray &iv, bool pad);
  162.  
  163.     private:
  164.         class Private;
  165.         Private *d;
  166.     };
  167.  
  168.     template <class T>
  169.     class QCA_EXPORT CipherStatic
  170.     {
  171.     public:
  172.         CipherStatic<T>() {}
  173.  
  174.         static QByteArray generateKey(int size=-1)
  175.         {
  176.             T obj;
  177.             return obj.dyn_generateKey(size);
  178.         }
  179.  
  180.         static QByteArray generateIV()
  181.         {
  182.             T obj;
  183.             return obj.dyn_generateIV();
  184.         }
  185.     };
  186.  
  187.     class QCA_EXPORT SHA1 : public Hash, public HashStatic<SHA1>
  188.     {
  189.     public:
  190.         SHA1();
  191.     };
  192.  
  193.     class QCA_EXPORT SHA256 : public Hash, public HashStatic<SHA256>
  194.     {
  195.     public:
  196.         SHA256();
  197.     };
  198.  
  199.     class QCA_EXPORT MD5 : public Hash, public HashStatic<MD5>
  200.     {
  201.     public:
  202.         MD5();
  203.     };
  204.  
  205.     class QCA_EXPORT BlowFish : public Cipher, public CipherStatic<BlowFish>
  206.     {
  207.     public:
  208.         BlowFish(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
  209.     };
  210.  
  211.     class QCA_EXPORT TripleDES : public Cipher, public CipherStatic<TripleDES>
  212.     {
  213.     public:
  214.         TripleDES(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
  215.     };
  216.  
  217.     class QCA_EXPORT AES128 : public Cipher, public CipherStatic<AES128>
  218.     {
  219.     public:
  220.         AES128(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
  221.     };
  222.  
  223.     class QCA_EXPORT AES256 : public Cipher, public CipherStatic<AES256>
  224.     {
  225.     public:
  226.         AES256(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
  227.     };
  228.  
  229.     class RSA;
  230.     class QCA_EXPORT RSAKey
  231.     {
  232.     public:
  233.         RSAKey();
  234.         RSAKey(const RSAKey &from);
  235.         RSAKey & operator=(const RSAKey &from);
  236.         ~RSAKey();
  237.  
  238.         bool isNull() const;
  239.         bool havePublic() const;
  240.         bool havePrivate() const;
  241.  
  242.         QByteArray toDER(bool publicOnly=false) const;
  243.         bool fromDER(const QByteArray &a);
  244.  
  245.         QString toPEM(bool publicOnly=false) const;
  246.         bool fromPEM(const QString &);
  247.  
  248.         // only call if you know what you are doing
  249.         bool fromNative(void *);
  250.  
  251.     private:
  252.         class Private;
  253.         Private *d;
  254.  
  255.         friend class RSA;
  256.         friend class TLS;
  257.         bool encrypt(const QByteArray &a, QByteArray *out, bool oaep) const;
  258.         bool decrypt(const QByteArray &a, QByteArray *out, bool oaep) const;
  259.         bool generate(unsigned int bits);
  260.     };
  261.  
  262.     class QCA_EXPORT RSA
  263.     {
  264.     public:
  265.         RSA();
  266.         ~RSA();
  267.  
  268.         RSAKey key() const;
  269.         void setKey(const RSAKey &);
  270.  
  271.         bool encrypt(const QByteArray &a, QByteArray *out, bool oaep=false) const;
  272.         bool decrypt(const QByteArray &a, QByteArray *out, bool oaep=false) const;
  273.  
  274.         static RSAKey generateKey(unsigned int bits);
  275.  
  276.     private:
  277.         RSAKey v_key;
  278.     };
  279.  
  280.     typedef QMap<QString, QString> CertProperties;
  281.     class QCA_EXPORT Cert
  282.     {
  283.     public:
  284.         Cert();
  285.         Cert(const Cert &);
  286.         Cert & operator=(const Cert &);
  287.         ~Cert();
  288.  
  289.         bool isNull() const;
  290.  
  291.         QString commonName() const;
  292.         QString serialNumber() const;
  293.         QString subjectString() const;
  294.         QString issuerString() const;
  295.         CertProperties subject() const;
  296.         CertProperties issuer() const;
  297.         QDateTime notBefore() const;
  298.         QDateTime notAfter() const;
  299.  
  300.         QByteArray toDER() const;
  301.         bool fromDER(const QByteArray &a);
  302.  
  303.         QString toPEM() const;
  304.         bool fromPEM(const QString &);
  305.  
  306.     private:
  307.         class Private;
  308.         Private *d;
  309.  
  310.         friend class TLS;
  311.         void fromContext(QCA_CertContext *);
  312.     };
  313.  
  314.     class QCA_EXPORT TLS : public QObject
  315.     {
  316.         Q_OBJECT
  317.     public:
  318.         enum Validity {
  319.             NoCert,
  320.             Valid,
  321.             HostMismatch,
  322.             Rejected,
  323.             Untrusted,
  324.             SignatureFailed,
  325.             InvalidCA,
  326.             InvalidPurpose,
  327.             SelfSigned,
  328.             Revoked,
  329.             PathLengthExceeded,
  330.             Expired,
  331.             Unknown
  332.         };
  333.         enum Error { ErrHandshake, ErrCrypt };
  334.  
  335.         TLS(QObject *parent=0);
  336.         ~TLS();
  337.  
  338.         void setCertificate(const Cert &cert, const RSAKey &key);
  339.         void setCertificateStore(const QPtrList<Cert> &store);  // note: store must persist
  340.  
  341.         void reset();
  342.         bool startClient(const QString &host="");
  343.         bool startServer();
  344.         void close();
  345.         bool isHandshaken() const;
  346.  
  347.         // plain (application side)
  348.         void write(const QByteArray &a);
  349.         QByteArray read();
  350.  
  351.         // encoded (socket side)
  352.         void writeIncoming(const QByteArray &a);
  353.         QByteArray readOutgoing();
  354.         QByteArray readUnprocessed();
  355.  
  356.         // cert related
  357.         const Cert & peerCertificate() const;
  358.         int certificateValidityResult() const;
  359.  
  360.     signals:
  361.         void handshaken();
  362.         void readyRead();
  363.         void readyReadOutgoing(int plainBytes);
  364.         void closed();
  365.         void error(int);
  366.  
  367.     private slots:
  368.         void update();
  369.  
  370.     private:
  371.         class Private;
  372.         Private *d;
  373.     };
  374.  
  375.     class QCA_EXPORT SASL : public QObject
  376.     {
  377.         Q_OBJECT
  378.     public:
  379.         enum Error { ErrAuth, ErrCrypt };
  380.         enum ErrorCond {
  381.             NoMech,
  382.             BadProto,
  383.             BadServ,
  384.             BadAuth,
  385.             NoAuthzid,
  386.             TooWeak,
  387.             NeedEncrypt,
  388.             Expired,
  389.             Disabled,
  390.             NoUser,
  391.             RemoteUnavail
  392.         };
  393.         SASL(QObject *parent=0);
  394.         ~SASL();
  395.  
  396.         static void setAppName(const QString &name);
  397.  
  398.         void reset();
  399.         int errorCondition() const;
  400.  
  401.         // options
  402.         void setAllowPlain(bool);
  403.         void setAllowAnonymous(bool);
  404.         void setAllowActiveVulnerable(bool);
  405.         void setAllowDictionaryVulnerable(bool);
  406.         void setRequireForwardSecrecy(bool);
  407.         void setRequirePassCredentials(bool);
  408.         void setRequireMutualAuth(bool);
  409.  
  410.         void setMinimumSSF(int);
  411.         void setMaximumSSF(int);
  412.         void setExternalAuthID(const QString &authid);
  413.         void setExternalSSF(int);
  414.  
  415.         void setLocalAddr(const QHostAddress &addr, Q_UINT16 port);
  416.         void setRemoteAddr(const QHostAddress &addr, Q_UINT16 port);
  417.  
  418.         // initialize
  419.         bool startClient(const QString &service, const QString &host, const QStringList &mechlist, bool allowClientSendFirst=true);
  420.         bool startServer(const QString &service, const QString &host, const QString &realm, QStringList *mechlist);
  421.  
  422.         // authentication
  423.         void putStep(const QByteArray &stepData);
  424.         void putServerFirstStep(const QString &mech);
  425.         void putServerFirstStep(const QString &mech, const QByteArray &clientInit);
  426.         void setUsername(const QString &user);
  427.         void setAuthzid(const QString &auth);
  428.         void setPassword(const QString &pass);
  429.         void setRealm(const QString &realm);
  430.         void continueAfterParams();
  431.         void continueAfterAuthCheck();
  432.  
  433.         // security layer
  434.         int ssf() const;
  435.         void write(const QByteArray &a);
  436.         QByteArray read();
  437.         void writeIncoming(const QByteArray &a);
  438.         QByteArray readOutgoing();
  439.  
  440.     signals:
  441.         // for authentication
  442.         void clientFirstStep(const QString &mech, const QByteArray *clientInit);
  443.         void nextStep(const QByteArray &stepData);
  444.         void needParams(bool user, bool authzid, bool pass, bool realm);
  445.         void authCheck(const QString &user, const QString &authzid);
  446.         void authenticated();
  447.  
  448.         // for security layer
  449.         void readyRead();
  450.         void readyReadOutgoing(int plainBytes);
  451.  
  452.         // error
  453.         void error(int);
  454.  
  455.     private slots:
  456.         void tryAgain();
  457.  
  458.     private:
  459.         class Private;
  460.         Private *d;
  461.  
  462.         void handleServerFirstStep(int r);
  463.     };
  464. };
  465.  
  466. #endif
  467.